home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 2 / AACD 2.iso / AACD / Programming / jikes-1.02 / src / modifier.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1999-04-12  |  41.1 KB  |  1,008 lines
  1. // $Id: modifier.cpp,v 1.6 1999/04/12 18:22:47 shields Exp $
  2. //
  3. // This software is subject to the terms of the IBM Jikes Compiler
  4. // License Agreement available at the following URL:
  5. // http://www.ibm.com/research/jikes.
  6. // Copyright (C) 1996, 1998, International Business Machines Corporation
  7. // and others.  All Rights Reserved.
  8. // You must accept the terms of that agreement to use this software.
  9. //
  10. #include "config.h"
  11. #include "semantic.h"
  12.  
  13. AccessFlags Semantic::ProcessClassModifiers(AstClassDeclaration *class_declaration)
  14. {
  15.     AccessFlags access_flags;
  16.  
  17.     for (int i = 0; i < class_declaration -> NumClassModifiers(); i++)
  18.     {
  19.         AstModifier *modifier = class_declaration -> ClassModifier(i);
  20.  
  21.         switch(modifier -> kind)
  22.         {
  23.             case Ast::ABSTRACT:
  24.                  if (access_flags.ACC_ABSTRACT())
  25.                  {
  26.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  27.                                     modifier -> modifier_kind_token,
  28.                                     modifier -> modifier_kind_token);
  29.                  }
  30.                  else access_flags.SetACC_ABSTRACT();
  31.  
  32.                  if (access_flags.ACC_FINAL())
  33.                  {
  34.                      ReportSemError(SemanticError::FINAL_ABSTRACT_CLASS,
  35.                                     modifier -> modifier_kind_token,
  36.                                     modifier -> modifier_kind_token);
  37.                  }
  38.                  break;
  39.             case Ast::FINAL:
  40.                  if (access_flags.ACC_FINAL())
  41.                  {
  42.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  43.                                     modifier -> modifier_kind_token,
  44.                                     modifier -> modifier_kind_token);
  45.                  }
  46.                  else access_flags.SetACC_FINAL();
  47.  
  48.                  if (access_flags.ACC_ABSTRACT())
  49.                  {
  50.                      ReportSemError(SemanticError::FINAL_ABSTRACT_CLASS,
  51.                                     modifier -> modifier_kind_token,
  52.                                     modifier -> modifier_kind_token);
  53.                  }
  54.                  break;
  55.             case Ast::PUBLIC:
  56.                  if (access_flags.ACC_PUBLIC())
  57.                  {
  58.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  59.                                     modifier -> modifier_kind_token,
  60.                                     modifier -> modifier_kind_token);
  61.                  }
  62.                  else access_flags.SetACC_PUBLIC();
  63.                  break;
  64.             case Ast::STRICTFP:
  65.                  if (access_flags.ACC_STRICTFP())
  66.                  {
  67.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  68.                                     modifier -> modifier_kind_token,
  69.                                     modifier -> modifier_kind_token);
  70.                  }
  71.                  else access_flags.SetACC_STRICTFP();
  72.                  break;
  73.             default:
  74.                  ReportSemError(SemanticError::INVALID_TOP_LEVEL_CLASS_MODIFIER,
  75.                                 modifier -> modifier_kind_token,
  76.                                 modifier -> modifier_kind_token,
  77.                                 lex_stream -> NameString(modifier -> modifier_kind_token));
  78.                  break;
  79.         }
  80.     }
  81.  
  82.     return access_flags;
  83. }
  84.  
  85.  
  86.  
  87. AccessFlags Semantic::ProcessLocalClassModifiers(AstClassDeclaration *class_declaration)
  88. {
  89.     AccessFlags access_flags;
  90.  
  91.     for (int i = 0; i < class_declaration -> NumClassModifiers(); i++)
  92.     {
  93.         AstModifier *modifier = class_declaration -> ClassModifier(i);
  94.  
  95.         switch(modifier -> kind)
  96.         {
  97.             case Ast::ABSTRACT:
  98.                  if (access_flags.ACC_ABSTRACT())
  99.                  {
  100.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  101.                                     modifier -> modifier_kind_token,
  102.                                     modifier -> modifier_kind_token);
  103.                  }
  104.                  else access_flags.SetACC_ABSTRACT();
  105.  
  106.                  if (access_flags.ACC_FINAL())
  107.                  {
  108.                      ReportSemError(SemanticError::FINAL_ABSTRACT_CLASS,
  109.                                     modifier -> modifier_kind_token,
  110.                                     modifier -> modifier_kind_token);
  111.                  }
  112.                  break;
  113.             case Ast::FINAL:
  114.                  if (access_flags.ACC_FINAL())
  115.                  {
  116.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  117.                                     modifier -> modifier_kind_token,
  118.                                     modifier -> modifier_kind_token);
  119.                  }
  120.                  else access_flags.SetACC_FINAL();
  121.  
  122.                  if (access_flags.ACC_ABSTRACT())
  123.                  {
  124.                      ReportSemError(SemanticError::FINAL_ABSTRACT_CLASS,
  125.                                     modifier -> modifier_kind_token,
  126.                                     modifier -> modifier_kind_token);
  127.                  }
  128.                  break;
  129.             case Ast::STRICTFP:
  130.                  if (access_flags.ACC_STRICTFP())
  131.                  {
  132.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  133.                                     modifier -> modifier_kind_token,
  134.                                     modifier -> modifier_kind_token);
  135.                  }
  136.                  else access_flags.SetACC_STRICTFP();
  137.                  break;
  138.             default:
  139.                  ReportSemError(SemanticError::INVALID_LOCAL_CLASS_MODIFIER,
  140.                                 modifier -> modifier_kind_token,
  141.                                 modifier -> modifier_kind_token,
  142.                                 lex_stream -> NameString(modifier -> modifier_kind_token));
  143.                  break;
  144.         }
  145.     }
  146.  
  147.     return access_flags;
  148. }
  149.  
  150.  
  151. AccessFlags Semantic::ProcessNestedClassModifiers(AstClassDeclaration *class_declaration)
  152. {
  153.     AccessFlags access_flags;
  154.  
  155.     for (int i = 0; i < class_declaration -> NumClassModifiers(); i++)
  156.     {
  157.         AstModifier *modifier = class_declaration -> ClassModifier(i);
  158.  
  159.         switch(modifier -> kind)
  160.         {
  161.             case Ast::ABSTRACT:
  162.                  if (access_flags.ACC_ABSTRACT())
  163.                  {
  164.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  165.                                     modifier -> modifier_kind_token,
  166.                                     modifier -> modifier_kind_token);
  167.                  }
  168.                  else access_flags.SetACC_ABSTRACT();
  169.  
  170.                  if (access_flags.ACC_FINAL())
  171.                  {
  172.                      ReportSemError(SemanticError::FINAL_ABSTRACT_CLASS,
  173.                                     modifier -> modifier_kind_token,
  174.                                     modifier -> modifier_kind_token);
  175.                  }
  176.                  break;
  177.             case Ast::FINAL:
  178.                  if (access_flags.ACC_FINAL())
  179.                  {
  180.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  181.                                     modifier -> modifier_kind_token,
  182.                                     modifier -> modifier_kind_token);
  183.                  }
  184.                  else access_flags.SetACC_FINAL();
  185.  
  186.                  if (access_flags.ACC_ABSTRACT())
  187.                  {
  188.                      ReportSemError(SemanticError::FINAL_ABSTRACT_CLASS,
  189.                                     modifier -> modifier_kind_token,
  190.                                     modifier -> modifier_kind_token);
  191.                  }
  192.                  break;
  193.             case Ast::PUBLIC:
  194.                  if (access_flags.ACC_PUBLIC() || access_flags.ACC_PROTECTED() || access_flags.ACC_PRIVATE())
  195.                  {
  196.                      ReportSemError(SemanticError::DUPLICATE_ACCESS_MODIFIER,
  197.                                     modifier -> modifier_kind_token,
  198.                                     modifier -> modifier_kind_token);
  199.                  }
  200.                  else access_flags.SetACC_PUBLIC();
  201.                  break;
  202.             case Ast::PRIVATE:
  203.                  if (access_flags.ACC_PUBLIC() || access_flags.ACC_PROTECTED() || access_flags.ACC_PRIVATE())
  204.                  {
  205.                      ReportSemError(SemanticError::DUPLICATE_ACCESS_MODIFIER,
  206.                                     modifier -> modifier_kind_token,
  207.                                     modifier -> modifier_kind_token);
  208.                  }
  209.                  else access_flags.SetACC_PRIVATE();
  210.                  break;
  211.             case Ast::PROTECTED:
  212.                  if (access_flags.ACC_PUBLIC() || access_flags.ACC_PROTECTED() || access_flags.ACC_PRIVATE())
  213.                  {
  214.                      ReportSemError(SemanticError::DUPLICATE_ACCESS_MODIFIER,
  215.                                     modifier -> modifier_kind_token,
  216.                                     modifier -> modifier_kind_token);
  217.                  }
  218.                  else access_flags.SetACC_PROTECTED();
  219.                  break;
  220.             case Ast::STATIC:
  221.                  if (access_flags.ACC_STATIC())
  222.                  {
  223.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  224.                                     modifier -> modifier_kind_token,
  225.                                     modifier -> modifier_kind_token);
  226.                  }
  227.                  else access_flags.SetACC_STATIC();
  228.                  break;
  229.             case Ast::STRICTFP:
  230.                  if (access_flags.ACC_STRICTFP())
  231.                  {
  232.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  233.                                     modifier -> modifier_kind_token,
  234.                                     modifier -> modifier_kind_token);
  235.                  }
  236.                  else access_flags.SetACC_STRICTFP();
  237.                  break;
  238.             default:
  239.                  ReportSemError(SemanticError::INVALID_INNER_CLASS_MODIFIER,
  240.                                 modifier -> modifier_kind_token,
  241.                                 modifier -> modifier_kind_token,
  242.                                 lex_stream -> NameString(modifier -> modifier_kind_token));
  243.                  break;
  244.         }
  245.     }
  246.  
  247.     return access_flags;
  248. }
  249.  
  250.  
  251. AccessFlags Semantic::ProcessStaticNestedClassModifiers(AstClassDeclaration *class_declaration)
  252. {
  253.     AccessFlags access_flags;
  254.  
  255.     for (int i = 0; i < class_declaration -> NumClassModifiers(); i++)
  256.     {
  257.         AstModifier *modifier = class_declaration -> ClassModifier(i);
  258.  
  259.         switch(modifier -> kind)
  260.         {
  261.             case Ast::ABSTRACT:
  262.                  if (access_flags.ACC_ABSTRACT())
  263.                  {
  264.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  265.                                     modifier -> modifier_kind_token,
  266.                                     modifier -> modifier_kind_token);
  267.                  }
  268.                  else access_flags.SetACC_ABSTRACT();
  269.  
  270.                  if (access_flags.ACC_FINAL())
  271.                  {
  272.                      ReportSemError(SemanticError::FINAL_ABSTRACT_CLASS,
  273.                                     modifier -> modifier_kind_token,
  274.                                     modifier -> modifier_kind_token);
  275.                  }
  276.                  break;
  277.             case Ast::FINAL:
  278.                  if (access_flags.ACC_FINAL())
  279.                  {
  280.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  281.                                     modifier -> modifier_kind_token,
  282.                                     modifier -> modifier_kind_token);
  283.                  }
  284.                  else access_flags.SetACC_FINAL();
  285.  
  286.                  if (access_flags.ACC_ABSTRACT())
  287.                  {
  288.                      ReportSemError(SemanticError::FINAL_ABSTRACT_CLASS,
  289.                                     modifier -> modifier_kind_token,
  290.                                     modifier -> modifier_kind_token);
  291.                  }
  292.                  break;
  293.             case Ast::PUBLIC:
  294.                  if (access_flags.ACC_PUBLIC() || access_flags.ACC_PROTECTED() || access_flags.ACC_PRIVATE())
  295.                  {
  296.                      ReportSemError(SemanticError::DUPLICATE_ACCESS_MODIFIER,
  297.                                     modifier -> modifier_kind_token,
  298.                                     modifier -> modifier_kind_token);
  299.                  }
  300.                  else
  301.                  {
  302.                      if (control.option.pedantic)
  303.                          ReportSemError(SemanticError::REDUNDANT_PUBLIC,
  304.                                         modifier -> modifier_kind_token,
  305.                                         modifier -> modifier_kind_token);
  306.                      access_flags.SetACC_PUBLIC();
  307.                  }
  308.                  break;
  309.             case Ast::STATIC:
  310.                  if (access_flags.ACC_STATIC())
  311.                  {
  312.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  313.                                     modifier -> modifier_kind_token,
  314.                                     modifier -> modifier_kind_token);
  315.                  }
  316.                  else
  317.                  {
  318.                      if (control.option.pedantic)
  319.                          ReportSemError(SemanticError::REDUNDANT_STATIC,
  320.                                         modifier -> modifier_kind_token,
  321.                                         modifier -> modifier_kind_token);
  322.                      access_flags.SetACC_STATIC();
  323.                  }
  324.                  break;
  325.             case Ast::STRICTFP:
  326.                  if (access_flags.ACC_STRICTFP())
  327.                  {
  328.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  329.                                     modifier -> modifier_kind_token,
  330.                                     modifier -> modifier_kind_token);
  331.                  }
  332.                  else access_flags.SetACC_STRICTFP();
  333.                  break;
  334.             default:
  335.                  ReportSemError(SemanticError::INVALID_INNER_CLASS_MODIFIER,
  336.                                 modifier -> modifier_kind_token,
  337.                                 modifier -> modifier_kind_token,
  338.                                 lex_stream -> NameString(modifier -> modifier_kind_token));
  339.                  break;
  340.         }
  341.     }
  342.  
  343.     //
  344.     // A type that is a member of an interface is implicitly deemed to
  345.     // be static and public, whether it is explicitly marked so or not.
  346.     //
  347.     access_flags.SetACC_STATIC();
  348.     access_flags.SetACC_PUBLIC();
  349.  
  350.     return access_flags;
  351. }
  352.  
  353.  
  354. AccessFlags Semantic::ProcessInterfaceModifiers(AstInterfaceDeclaration *interface_declaration)
  355. {
  356.     AccessFlags access_flags;
  357.  
  358.     for (int i = 0; i < interface_declaration -> NumInterfaceModifiers(); i++)
  359.     {
  360.         AstModifier *modifier = interface_declaration -> InterfaceModifier(i);
  361.  
  362.         switch(modifier -> kind)
  363.         {
  364.             case Ast::ABSTRACT:
  365.                  if (access_flags.ACC_ABSTRACT())
  366.                  {
  367.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  368.                                     modifier -> modifier_kind_token,
  369.                                     modifier -> modifier_kind_token);
  370.                  }
  371.                  else
  372.                  {
  373.                      ReportSemError(SemanticError::OBSOLESCENT_ABSTRACT,
  374.                                     modifier -> modifier_kind_token,
  375.                                     modifier -> modifier_kind_token);
  376.                      access_flags.SetACC_ABSTRACT();
  377.                  }
  378.                  break;
  379.             case Ast::PUBLIC:
  380.                  if (access_flags.ACC_PUBLIC())
  381.                  {
  382.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  383.                                     modifier -> modifier_kind_token,
  384.                                     modifier -> modifier_kind_token);
  385.                  }
  386.                  else access_flags.SetACC_PUBLIC();
  387.                  break;
  388.             case Ast::STRICTFP:
  389.                  if (access_flags.ACC_STRICTFP())
  390.                  {
  391.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  392.                                     modifier -> modifier_kind_token,
  393.                                     modifier -> modifier_kind_token);
  394.                  }
  395.                  else access_flags.SetACC_STRICTFP();
  396.                  break;
  397.             default:
  398.                  ReportSemError(SemanticError::INVALID_INTERFACE_MODIFIER,
  399.                                 modifier -> modifier_kind_token,
  400.                                 modifier -> modifier_kind_token,
  401.                                 lex_stream -> NameString(modifier -> modifier_kind_token));
  402.                  break;
  403.         }
  404.     }
  405.  
  406.     access_flags.SetACC_INTERFACE();
  407.     access_flags.SetACC_ABSTRACT(); // every interface is implicitly abstract
  408.  
  409.     return access_flags;
  410. }
  411.  
  412.  
  413. AccessFlags Semantic::ProcessNestedInterfaceModifiers(AstInterfaceDeclaration *interface_declaration)
  414. {
  415.     AccessFlags access_flags;
  416.  
  417.     for (int i = 0; i < interface_declaration -> NumInterfaceModifiers(); i++)
  418.     {
  419.         AstModifier *modifier = interface_declaration -> InterfaceModifier(i);
  420.  
  421.         switch(modifier -> kind)
  422.         {
  423.             case Ast::ABSTRACT:
  424.                  if (access_flags.ACC_ABSTRACT())
  425.                  {
  426.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  427.                                     modifier -> modifier_kind_token,
  428.                                     modifier -> modifier_kind_token);
  429.                  }
  430.                  else
  431.                  {
  432.                      ReportSemError(SemanticError::OBSOLESCENT_ABSTRACT,
  433.                                     modifier -> modifier_kind_token,
  434.                                     modifier -> modifier_kind_token);
  435.                      access_flags.SetACC_ABSTRACT();
  436.                  }
  437.                  break;
  438.             case Ast::PUBLIC:
  439.                  if (access_flags.ACC_PUBLIC() || access_flags.ACC_PROTECTED() || access_flags.ACC_PRIVATE())
  440.                  {
  441.                      ReportSemError(SemanticError::DUPLICATE_ACCESS_MODIFIER,
  442.                                     modifier -> modifier_kind_token,
  443.                                     modifier -> modifier_kind_token);
  444.                  }
  445.                  else access_flags.SetACC_PUBLIC();
  446.                  break;
  447.             case Ast::PRIVATE:
  448.                  if (access_flags.ACC_PUBLIC() || access_flags.ACC_PROTECTED() || access_flags.ACC_PRIVATE())
  449.                  {
  450.                      ReportSemError(SemanticError::DUPLICATE_ACCESS_MODIFIER,
  451.                                     modifier -> modifier_kind_token,
  452.                                     modifier -> modifier_kind_token);
  453.                  }
  454.                  else access_flags.SetACC_PRIVATE();
  455.                  break;
  456.             case Ast::PROTECTED:
  457.                  if (access_flags.ACC_PUBLIC() || access_flags.ACC_PROTECTED() || access_flags.ACC_PRIVATE())
  458.                  {
  459.                      ReportSemError(SemanticError::DUPLICATE_ACCESS_MODIFIER,
  460.                                     modifier -> modifier_kind_token,
  461.                                     modifier -> modifier_kind_token);
  462.                  }
  463.                  else access_flags.SetACC_PROTECTED();
  464.                  break;
  465.             case Ast::STATIC: // TODO: Need to confirm that this is valid !!!
  466.                  if (access_flags.ACC_STATIC())
  467.                  {
  468.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  469.                                     modifier -> modifier_kind_token,
  470.                                     modifier -> modifier_kind_token);
  471.                  }
  472.                  else
  473.                  {
  474.                      if (control.option.pedantic)
  475.                          ReportSemError(SemanticError::REDUNDANT_STATIC,
  476.                                         modifier -> modifier_kind_token,
  477.                                         modifier -> modifier_kind_token);
  478.                      access_flags.SetACC_STATIC();
  479.                  }
  480.                  break;
  481.             case Ast::STRICTFP:
  482.                  if (access_flags.ACC_STRICTFP())
  483.                  {
  484.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  485.                                     modifier -> modifier_kind_token,
  486.                                     modifier -> modifier_kind_token);
  487.                  }
  488.                  else access_flags.SetACC_STRICTFP();
  489.                  break;
  490.             default:
  491.                  ReportSemError(SemanticError::INVALID_INTERFACE_MODIFIER,
  492.                                 modifier -> modifier_kind_token,
  493.                                 modifier -> modifier_kind_token,
  494.                                 lex_stream -> NameString(modifier -> modifier_kind_token));
  495.                  break;
  496.         }
  497.     }
  498.  
  499.     access_flags.SetACC_INTERFACE();
  500.     access_flags.SetACC_ABSTRACT(); // every interface is implicitly abstract
  501.     access_flags.SetACC_STATIC();   // every inner interface is implicitly static
  502.  
  503.     return access_flags;
  504. }
  505.  
  506.  
  507. AccessFlags Semantic::ProcessFieldModifiers(AstFieldDeclaration *field_declaration)
  508. {
  509.     AccessFlags access_flags;
  510.  
  511.     for (int i = 0; i < field_declaration -> NumVariableModifiers(); i++)
  512.     {
  513.         AstModifier *modifier = field_declaration -> VariableModifier(i);
  514.  
  515.         switch(modifier -> kind)
  516.         {
  517.             case Ast::PUBLIC:
  518.                  if (access_flags.ACC_PUBLIC() || access_flags.ACC_PROTECTED() || access_flags.ACC_PRIVATE())
  519.                  {
  520.                      ReportSemError(SemanticError::DUPLICATE_ACCESS_MODIFIER,
  521.                                     modifier -> modifier_kind_token,
  522.                                     modifier -> modifier_kind_token);
  523.                  }
  524.                  else access_flags.SetACC_PUBLIC();
  525.                  break;
  526.             case Ast::PROTECTED:
  527.                  if (access_flags.ACC_PUBLIC() || access_flags.ACC_PROTECTED() || access_flags.ACC_PRIVATE())
  528.                  {
  529.                      ReportSemError(SemanticError::DUPLICATE_ACCESS_MODIFIER,
  530.                                     modifier -> modifier_kind_token,
  531.                                     modifier -> modifier_kind_token);
  532.                  }
  533.                  else access_flags.SetACC_PROTECTED();
  534.                  break;
  535.             case Ast::PRIVATE:
  536.                  if (access_flags.ACC_PUBLIC() || access_flags.ACC_PROTECTED() || access_flags.ACC_PRIVATE())
  537.                  {
  538.                      ReportSemError(SemanticError::DUPLICATE_ACCESS_MODIFIER,
  539.                                     modifier -> modifier_kind_token,
  540.                                     modifier -> modifier_kind_token);
  541.                  }
  542.                  else access_flags.SetACC_PRIVATE();
  543.                  break;
  544.             case Ast::STATIC:
  545.                  if (access_flags.ACC_STATIC())
  546.                  {
  547.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  548.                                     modifier -> modifier_kind_token,
  549.                                     modifier -> modifier_kind_token);
  550.                  }
  551.                  else access_flags.SetACC_STATIC();
  552.                  break;
  553.             case Ast::FINAL:
  554.                  if (access_flags.ACC_FINAL())
  555.                  {
  556.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  557.                                     modifier -> modifier_kind_token,
  558.                                     modifier -> modifier_kind_token);
  559.                  }
  560.                  else access_flags.SetACC_FINAL();
  561.  
  562.                  if (access_flags.ACC_VOLATILE())
  563.                  {
  564.                      ReportSemError(SemanticError::FINAL_VOLATILE,
  565.                                     modifier -> modifier_kind_token,
  566.                                     modifier -> modifier_kind_token);
  567.                  }
  568.                  break;
  569.             case Ast::TRANSIENT:
  570.                  if (access_flags.ACC_TRANSIENT())
  571.                  {
  572.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  573.                                     modifier -> modifier_kind_token,
  574.                                     modifier -> modifier_kind_token);
  575.                  }
  576.                  else access_flags.SetACC_TRANSIENT();
  577.                  break;
  578.             case Ast::VOLATILE:
  579.                  if (access_flags.ACC_VOLATILE())
  580.                  {
  581.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  582.                                     modifier -> modifier_kind_token,
  583.                                     modifier -> modifier_kind_token);
  584.                  }
  585.                  else access_flags.SetACC_VOLATILE();
  586.  
  587.                  if (access_flags.ACC_FINAL())
  588.                  {
  589.                      ReportSemError(SemanticError::VOLATILE_FINAL,
  590.                                     modifier -> modifier_kind_token,
  591.                                     modifier -> modifier_kind_token);
  592.                  }
  593.                  break;
  594.             default:
  595.                  ReportSemError(SemanticError::INVALID_FIELD_MODIFIER,
  596.                                 modifier -> modifier_kind_token,
  597.                                 modifier -> modifier_kind_token,
  598.                                 lex_stream -> NameString(modifier -> modifier_kind_token));
  599.                  break;
  600.         }
  601.     }
  602.  
  603.     return access_flags;
  604. }
  605.  
  606.  
  607. AccessFlags Semantic::ProcessLocalModifiers(AstLocalVariableDeclarationStatement *local_declaration)
  608. {
  609.     AccessFlags access_flags;
  610.  
  611.     for (int i = 0; i < local_declaration -> NumLocalModifiers(); i++)
  612.     {
  613.         AstModifier *modifier = local_declaration -> LocalModifier(i);
  614.  
  615.         if (modifier -> kind == Ast::FINAL)
  616.         {
  617.             if (access_flags.ACC_FINAL())
  618.             {
  619.                 ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  620.                                modifier -> modifier_kind_token,
  621.                                modifier -> modifier_kind_token);
  622.             }
  623.             else access_flags.SetACC_FINAL();
  624.         }
  625.         else
  626.         {
  627.             ReportSemError(SemanticError::INVALID_LOCAL_MODIFIER,
  628.                            modifier -> modifier_kind_token,
  629.                            modifier -> modifier_kind_token,
  630.                            lex_stream -> NameString(modifier -> modifier_kind_token));
  631.         }
  632.     }
  633.  
  634.     return access_flags;
  635. }
  636.  
  637.  
  638. AccessFlags Semantic::ProcessFormalModifiers(AstFormalParameter *parameter_declaration)
  639. {
  640.     AccessFlags access_flags;
  641.  
  642.     for (int i = 0; i < parameter_declaration -> NumParameterModifiers(); i++)
  643.     {
  644.         AstModifier *modifier = parameter_declaration -> ParameterModifier(i);
  645.  
  646.         if (modifier -> kind == Ast::FINAL)
  647.         {
  648.             if (access_flags.ACC_FINAL())
  649.             {
  650.                 ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  651.                                modifier -> modifier_kind_token,
  652.                                modifier -> modifier_kind_token);
  653.             }
  654.             else access_flags.SetACC_FINAL();
  655.         }
  656.         else
  657.         {
  658.             ReportSemError(SemanticError::INVALID_LOCAL_MODIFIER,
  659.                            modifier -> modifier_kind_token,
  660.                            modifier -> modifier_kind_token,
  661.                            lex_stream -> NameString(modifier -> modifier_kind_token));
  662.         }
  663.     }
  664.  
  665.     return access_flags;
  666. }
  667.  
  668.  
  669. AccessFlags Semantic::ProcessMethodModifiers(AstMethodDeclaration *method_declaration)
  670. {
  671.     AccessFlags access_flags;
  672.  
  673.     for (int i = 0; i < method_declaration -> NumMethodModifiers(); i++)
  674.     {
  675.         AstModifier *modifier = method_declaration -> MethodModifier(i);
  676.  
  677.         switch(modifier -> kind)
  678.         {
  679.             case Ast::PUBLIC:
  680.                  if (access_flags.ACC_PUBLIC() || access_flags.ACC_PROTECTED() || access_flags.ACC_PRIVATE())
  681.                  {
  682.                      ReportSemError(SemanticError::DUPLICATE_ACCESS_MODIFIER,
  683.                                     modifier -> modifier_kind_token,
  684.                                     modifier -> modifier_kind_token);
  685.                  }
  686.                  else access_flags.SetACC_PUBLIC();
  687.                  break;
  688.             case Ast::PROTECTED:
  689.                  if (access_flags.ACC_PUBLIC() || access_flags.ACC_PROTECTED() || access_flags.ACC_PRIVATE())
  690.                  {
  691.                      ReportSemError(SemanticError::DUPLICATE_ACCESS_MODIFIER,
  692.                                     modifier -> modifier_kind_token,
  693.                                     modifier -> modifier_kind_token);
  694.                  }
  695.                  else access_flags.SetACC_PROTECTED();
  696.                  break;
  697.             case Ast::PRIVATE:
  698.                  if (access_flags.ACC_PUBLIC() || access_flags.ACC_PROTECTED() || access_flags.ACC_PRIVATE())
  699.                  {
  700.                      ReportSemError(SemanticError::DUPLICATE_ACCESS_MODIFIER,
  701.                                     modifier -> modifier_kind_token,
  702.                                     modifier -> modifier_kind_token);
  703.                  }
  704.                  else access_flags.SetACC_PRIVATE();
  705.  
  706.                  if (access_flags.ACC_ABSTRACT())
  707.                  {
  708.                      ReportSemError(SemanticError::ABSTRACT_METHOD_MODIFIER_CONFLICT,
  709.                                     modifier -> modifier_kind_token,
  710.                                     modifier -> modifier_kind_token,
  711.                                     lex_stream -> NameString(modifier -> modifier_kind_token));
  712.                  }
  713.                  break;
  714.             case Ast::STATIC:
  715.                  if (access_flags.ACC_STATIC())
  716.                  {
  717.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  718.                                     modifier -> modifier_kind_token,
  719.                                     modifier -> modifier_kind_token);
  720.                  }
  721.                  else access_flags.SetACC_STATIC();
  722.  
  723.                  if (access_flags.ACC_ABSTRACT())
  724.                  {
  725.                      ReportSemError(SemanticError::ABSTRACT_METHOD_MODIFIER_CONFLICT,
  726.                                     modifier -> modifier_kind_token,
  727.                                     modifier -> modifier_kind_token,
  728.                                     lex_stream -> NameString(modifier -> modifier_kind_token));
  729.                  }
  730.                  break;
  731.             case Ast::STRICTFP:
  732.                  if (access_flags.ACC_STRICTFP())
  733.                  {
  734.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  735.                                     modifier -> modifier_kind_token,
  736.                                     modifier -> modifier_kind_token);
  737.                  }
  738.                  else access_flags.SetACC_STRICTFP();
  739.                  break;
  740.             case Ast::ABSTRACT:
  741.                  if (access_flags.ACC_ABSTRACT())
  742.                  {
  743.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  744.                                     modifier -> modifier_kind_token,
  745.                                     modifier -> modifier_kind_token);
  746.                  }
  747.                  else access_flags.SetACC_ABSTRACT();
  748.  
  749.                  if (access_flags.ACC_PRIVATE() || access_flags.ACC_STATIC() ||
  750.                      access_flags.ACC_FINAL()   || access_flags.ACC_NATIVE() || access_flags.ACC_SYNCHRONIZED())
  751.                  {
  752.                      ReportSemError(SemanticError::BAD_ABSTRACT_METHOD_MODIFIER,
  753.                                     modifier -> modifier_kind_token,
  754.                                     modifier -> modifier_kind_token);
  755.                  }
  756.                  break;
  757.             case Ast::FINAL:
  758.                  if (access_flags.ACC_FINAL())
  759.                  {
  760.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  761.                                     modifier -> modifier_kind_token,
  762.                                     modifier -> modifier_kind_token);
  763.                  }
  764.                  else access_flags.SetACC_FINAL();
  765.  
  766.                  if (access_flags.ACC_ABSTRACT())
  767.                  {
  768.                      ReportSemError(SemanticError::ABSTRACT_METHOD_MODIFIER_CONFLICT,
  769.                                     modifier -> modifier_kind_token,
  770.                                     modifier -> modifier_kind_token,
  771.                                     lex_stream -> NameString(modifier -> modifier_kind_token));
  772.                  }
  773.                  break;
  774.             case Ast::NATIVE:
  775.                  if (access_flags.ACC_NATIVE())
  776.                  {
  777.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  778.                                     modifier -> modifier_kind_token,
  779.                                     modifier -> modifier_kind_token);
  780.                  }
  781.                  else access_flags.SetACC_NATIVE();
  782.  
  783.                  if (access_flags.ACC_ABSTRACT())
  784.                  {
  785.                      ReportSemError(SemanticError::ABSTRACT_METHOD_MODIFIER_CONFLICT,
  786.                                     modifier -> modifier_kind_token,
  787.                                     modifier -> modifier_kind_token,
  788.                                     lex_stream -> NameString(modifier -> modifier_kind_token));
  789.                  }
  790.                  break;
  791.             case Ast::SYNCHRONIZED:
  792.                  if (access_flags.ACC_SYNCHRONIZED())
  793.                  {
  794.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  795.                                     modifier -> modifier_kind_token,
  796.                                     modifier -> modifier_kind_token);
  797.                  }
  798.                  else access_flags.SetACC_SYNCHRONIZED();
  799.  
  800.                  if (access_flags.ACC_ABSTRACT())
  801.                  {
  802.                      ReportSemError(SemanticError::ABSTRACT_METHOD_MODIFIER_CONFLICT,
  803.                                     modifier -> modifier_kind_token,
  804.                                     modifier -> modifier_kind_token,
  805.                                     lex_stream -> NameString(modifier -> modifier_kind_token));
  806.                  }
  807.                  break;
  808.             default:
  809.                  ReportSemError(SemanticError::INVALID_METHOD_MODIFIER,
  810.                                 modifier -> modifier_kind_token,
  811.                                 modifier -> modifier_kind_token,
  812.                                 lex_stream -> NameString(modifier -> modifier_kind_token));
  813.                  break;
  814.         }
  815.     }
  816.  
  817.     return access_flags;
  818. }
  819.  
  820.  
  821. AccessFlags Semantic::ProcessAbstractMethodModifiers(AstMethodDeclaration *method_declaration)
  822. {
  823.     AccessFlags access_flags;
  824.  
  825.     for (int i = 0; i < method_declaration -> NumMethodModifiers(); i++)
  826.     {
  827.         AstModifier *modifier = method_declaration -> MethodModifier(i);
  828.  
  829.         switch(modifier -> kind)
  830.         {
  831.             case Ast::PUBLIC:
  832.                  if (access_flags.ACC_PUBLIC())
  833.                  {
  834.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  835.                                     modifier -> modifier_kind_token,
  836.                                     modifier -> modifier_kind_token);
  837.                  }
  838.                  else
  839.                  {
  840.                      if (control.option.pedantic)
  841.                          ReportSemError(SemanticError::REDUNDANT_PUBLIC,
  842.                                         modifier -> modifier_kind_token,
  843.                                         modifier -> modifier_kind_token);
  844.                      access_flags.SetACC_PUBLIC();
  845.                  }
  846.                  break;
  847.             case Ast::ABSTRACT:
  848.                  if (access_flags.ACC_ABSTRACT())
  849.                  {
  850.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  851.                                     modifier -> modifier_kind_token,
  852.                                     modifier -> modifier_kind_token);
  853.                  }
  854.                  else
  855.                  {
  856.                      if (control.option.pedantic)
  857.                          ReportSemError(SemanticError::REDUNDANT_ABSTRACT,
  858.                                         modifier -> modifier_kind_token,
  859.                                         modifier -> modifier_kind_token);
  860.                      access_flags.SetACC_ABSTRACT();
  861.                  }
  862.                  break;
  863.             default:
  864.                  ReportSemError(SemanticError::INVALID_SIGNATURE_MODIFIER,
  865.                                 modifier -> modifier_kind_token,
  866.                                 modifier -> modifier_kind_token,
  867.                                 lex_stream -> NameString(modifier -> modifier_kind_token));
  868.                  break;
  869.         }
  870.     }
  871.  
  872.     //
  873.     // Every method declaration in the body of an interface is implicitly "public" and "abstract"
  874.     //
  875.     access_flags.SetACC_ABSTRACT();
  876.     access_flags.SetACC_PUBLIC();
  877.  
  878.     return access_flags;
  879. }
  880.  
  881.  
  882. AccessFlags Semantic::ProcessConstructorModifiers(AstConstructorDeclaration *constructor_declaration)
  883. {
  884.     AccessFlags access_flags;
  885.  
  886.     for (int i = 0; i < constructor_declaration -> NumConstructorModifiers(); i++)
  887.     {
  888.         AstModifier *modifier = constructor_declaration -> ConstructorModifier(i);
  889.  
  890.         switch(modifier -> kind)
  891.         {
  892.             case Ast::PUBLIC:
  893.                  if (access_flags.ACC_PUBLIC() || access_flags.ACC_PROTECTED() || access_flags.ACC_PRIVATE())
  894.                  {
  895.                      ReportSemError(SemanticError::DUPLICATE_ACCESS_MODIFIER,
  896.                                     modifier -> modifier_kind_token,
  897.                                     modifier -> modifier_kind_token);
  898.                  }
  899.                  else access_flags.SetACC_PUBLIC();
  900.                  break;
  901.             case Ast::PROTECTED:
  902.                  if (access_flags.ACC_PUBLIC() || access_flags.ACC_PROTECTED() || access_flags.ACC_PRIVATE())
  903.                  {
  904.                      ReportSemError(SemanticError::DUPLICATE_ACCESS_MODIFIER,
  905.                                     modifier -> modifier_kind_token,
  906.                                     modifier -> modifier_kind_token);
  907.                  }
  908.                  else access_flags.SetACC_PROTECTED();
  909.                  break;
  910.             case Ast::PRIVATE:
  911.                  if (access_flags.ACC_PUBLIC() || access_flags.ACC_PROTECTED() || access_flags.ACC_PRIVATE())
  912.                  {
  913.                      ReportSemError(SemanticError::DUPLICATE_ACCESS_MODIFIER,
  914.                                     modifier -> modifier_kind_token,
  915.                                     modifier -> modifier_kind_token);
  916.                  }
  917.                  else access_flags.SetACC_PRIVATE();
  918.                  break;
  919.             default:
  920.                  ReportSemError(SemanticError::INVALID_CONSTRUCTOR_MODIFIER,
  921.                                 modifier -> modifier_kind_token,
  922.                                 modifier -> modifier_kind_token,
  923.                                 lex_stream -> NameString(modifier -> modifier_kind_token));
  924.                  break;
  925.         }
  926.     }
  927.  
  928.     return access_flags;
  929. }
  930.  
  931.  
  932. AccessFlags Semantic::ProcessConstantModifiers(AstFieldDeclaration *field_declaration)
  933. {
  934.     AccessFlags access_flags;
  935.  
  936.     for (int i = 0; i < field_declaration -> NumVariableModifiers(); i++)
  937.     {
  938.         AstModifier *modifier = field_declaration -> VariableModifier(i);
  939.  
  940.         switch(modifier -> kind)
  941.         {
  942.             case Ast::PUBLIC:
  943.                  if (access_flags.ACC_PUBLIC())
  944.                  {
  945.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  946.                                     modifier -> modifier_kind_token,
  947.                                     modifier -> modifier_kind_token);
  948.                  }
  949.                  else
  950.                  {
  951.                      if (control.option.pedantic)
  952.                          ReportSemError(SemanticError::REDUNDANT_PUBLIC,
  953.                                         modifier -> modifier_kind_token,
  954.                                         modifier -> modifier_kind_token);
  955.                      access_flags.SetACC_PUBLIC();
  956.                  }
  957.                  break;
  958.             case Ast::STATIC:
  959.                  if (access_flags.ACC_STATIC())
  960.                  {
  961.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  962.                                     modifier -> modifier_kind_token,
  963.                                     modifier -> modifier_kind_token);
  964.                  }
  965.                  else
  966.                  {
  967.                      if (control.option.pedantic)
  968.                          ReportSemError(SemanticError::REDUNDANT_STATIC,
  969.                                         modifier -> modifier_kind_token,
  970.                                         modifier -> modifier_kind_token);
  971.                      access_flags.SetACC_STATIC();
  972.                  }
  973.                  break;
  974.             case Ast::FINAL:
  975.                  if (access_flags.ACC_FINAL())
  976.                  {
  977.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  978.                                     modifier -> modifier_kind_token,
  979.                                     modifier -> modifier_kind_token);
  980.                  }
  981.                  else
  982.                  {
  983.                      if (control.option.pedantic)
  984.                          ReportSemError(SemanticError::REDUNDANT_FINAL,
  985.                                         modifier -> modifier_kind_token,
  986.                                         modifier -> modifier_kind_token);
  987.                      access_flags.SetACC_FINAL();
  988.                  }
  989.                  break;
  990.             default:
  991.                  ReportSemError(SemanticError::INVALID_CONSTANT_MODIFIER,
  992.                                 modifier -> modifier_kind_token,
  993.                                 modifier -> modifier_kind_token,
  994.                                 lex_stream -> NameString(modifier -> modifier_kind_token));
  995.                  break;
  996.         }
  997.     }
  998.  
  999.     //
  1000.     // Every constant (field) declaration in the body of an interface is implicitly "public", "static" and "final"
  1001.     //
  1002.     access_flags.SetACC_PUBLIC();
  1003.     access_flags.SetACC_STATIC();
  1004.     access_flags.SetACC_FINAL();
  1005.  
  1006.     return access_flags;
  1007. }
  1008.